package com.scl.reminder;

import android.annotation.SuppressLint;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.graphics.Color;
import android.net.Uri;
import android.provider.CalendarContract;

import java.util.Calendar;
import java.util.List;
import java.util.TimeZone;

/**
 * Created by admin on 2021/9/10.
 * name:
 */
public class CalendarReminderUtils {

    //日历用户的URL
    private static String CALENDER_URL = "content://com.android.calendar/calendars";
    //事件的URL
    private static String CALENDER_EVENT_URL = "content://com.android.calendar/events";
    //事件提醒的URL
    private static String CALENDER_REMINDER_URL = "content://com.android.calendar/reminders";

    /*账户信息*/
    private static String CALENDARS_NAME = "喝水鱼";
    private static String CALENDARS_ACCOUNT_NAME = "喝水鱼@gmail.com";
    private static String CALENDARS_ACCOUNT_TYPE = "com.android.exchange";
    private static String CALENDARS_DISPLAY_NAME = "喝水鱼";


    /**
     * 检查是否已经添加了日历账户，如果没有添加先添加一个日历账户再查询
     * 获取账户成功返回账户id，否则返回-1
     */
    private static int checkAndAddCalendarAccount(Context context) {
        int oldId = checkCalendarAccount(context);
        if (oldId >= 0) {
            return oldId;
        } else {
            long addId = addCalendarAccount(context);
            if (addId >= 0) {
                return checkCalendarAccount(context);
            } else {
                return -1;
            }
        }
    }

    /**
     * 检查是否存在现有账户，存在则返回账户id，否则返回-1
     */
    @SuppressLint("Range")
    private static int checkCalendarAccount(Context context) {
        Cursor userCursor = context.getContentResolver().query(Uri.parse(CALENDER_URL), null,
                null, null, null);
        try {
            if (userCursor == null) { //查询返回空值
                return -1;
            }
            int count = userCursor.getCount();
            if (count > 0) { //存在现有账户，取第一个账户的id返回
                userCursor.moveToFirst();
                return userCursor.getInt(userCursor.getColumnIndex(CalendarContract.Calendars._ID));
            } else {
                return -1;
            }
        } finally {
            if (userCursor != null) {
                userCursor.close();
            }
        }
    }

    /**
     * 添加日历账户，账户创建成功则返回账户id，否则返回-1
     */

    public static long addCalendarAccount(Context context) {
        ContentValues value = new ContentValues();
        //日历的名称
        value.put(CalendarContract.Calendars.NAME, CALENDARS_NAME);
        //设备上的帐户
        value.put(CalendarContract.Calendars.ACCOUNT_NAME, CALENDARS_ACCOUNT_NAME);
        //设备类型
        value.put(CalendarContract.Calendars.ACCOUNT_TYPE, CALENDARS_ACCOUNT_TYPE);
        //日历的显示名称。列名。
        value.put(CalendarContract.Calendars.CALENDAR_DISPLAY_NAME, CALENDARS_DISPLAY_NAME);

        value.put(CalendarContract.Calendars.VISIBLE, 1);
        value.put(CalendarContract.Calendars.CALENDAR_COLOR, Color.BLUE);
        value.put(CalendarContract.Calendars.CALENDAR_ACCESS_LEVEL, CalendarContract.Calendars.CAL_ACCESS_OWNER);
        value.put(CalendarContract.Calendars.SYNC_EVENTS, 1);
        value.put(CalendarContract.Calendars.CALENDAR_TIME_ZONE, TimeZone.getDefault().getID());
        value.put(CalendarContract.Calendars.OWNER_ACCOUNT, CALENDARS_ACCOUNT_NAME);
        value.put(CalendarContract.Calendars.CAN_ORGANIZER_RESPOND, 0);

        Uri calendarUri = Uri.parse(CALENDER_URL);
        calendarUri = calendarUri.buildUpon()
                .appendQueryParameter(CalendarContract.CALLER_IS_SYNCADAPTER, "true")
                .appendQueryParameter(CalendarContract.Calendars.ACCOUNT_NAME, CALENDARS_ACCOUNT_NAME)
                .appendQueryParameter(CalendarContract.Calendars.ACCOUNT_TYPE, CALENDARS_ACCOUNT_TYPE)
                .build();

        Uri result = context.getContentResolver().insert(calendarUri, value);
        long id = result == null ? -1 : ContentUris.parseId(result);
        return id;
    }

    /**
     * 写入事件到日历
     *
     * @param number 这个参数是 事件重复几次
     */
    private static void addCalendarEvent(Context context, String title, long reminderTime, int number,
                                         String site_sign, String description) {
        if (context == null) {
            return;
        }
        int calId = checkAndAddCalendarAccount(context); //获取日历账户的id
        if (calId < 0) { //获取账户id失败直接返回，添加日历事件失败
            return;
        }

        //添加日历事件
        Calendar mCalendar = Calendar.getInstance();
        mCalendar.setTimeInMillis(reminderTime);//设置开始时间
        long time = mCalendar.getTime().getTime();

        ContentValues event = new ContentValues();
        event.put("title", title);
        event.put("description", description);
        event.put("calendar_id", calId); //插入账户的id
        event.put("eventLocation", site_sign); //地址
        event.put(CalendarContract.Events.DTSTART, time);
        event.put(CalendarContract.Events.DURATION, "P0S"); // TODO 重复添加要加这个 不然重复可能无效
//        event.put(CalendarContract.Events.DTEND, end); //重复添加不需要 Events.DTEND
        event.put(CalendarContract.Events.HAS_ALARM, 1);//设置有闹钟提醒
        // TODO 重复规则 提醒number次
        event.put(CalendarContract.Events.RRULE, "FREQ=DAILY;COUNT=" + number);
        //TODO 重复规则 永久
        /*event.put(CalendarContract.Events.RRULE, "FREQ=WEEKLY;INTERVAL=1;WKST=SU;BYDAY=MO,TU,WE,TH,FR,SA,SU");*/
        event.put(CalendarContract.Events.EVENT_TIMEZONE, TimeZone.getDefault().getID());//这个是时区，必须有

        Uri newEvent = context.getContentResolver().insert(Uri.parse(CALENDER_EVENT_URL), event); //添加事件
        if (newEvent == null) { //添加日历事件失败直接返回
            return;
        }

        //事件提醒的设定
        ContentValues values = new ContentValues();
        values.put(CalendarContract.Reminders.EVENT_ID, ContentUris.parseId(newEvent));
        values.put(CalendarContract.Reminders.MINUTES, 0);// 提前多久 提醒
        values.put(CalendarContract.Reminders.METHOD, 1);
        Uri uri = context.getContentResolver().insert(Uri.parse(CALENDER_REMINDER_URL), values);
        if (uri == null) { //添加事件提醒失败直接返回
            return;
        }
    }

    /**
     * 删除日历事件
     */
    @SuppressLint("Range")
    public static void deleteCalendarEvent(Context context, String site_sign) {
        if (context == null) {
            return;
        }
        Cursor eventCursor = context.getContentResolver().query(Uri.parse(CALENDER_EVENT_URL),
                null, null, null, null);
        try {
            if (eventCursor == null) { //查询返回空值
                return;
            }
            if (eventCursor.getCount() > 0) {

                //遍历所有事件，找到title跟需要查询的title一样的项
                for (eventCursor.moveToFirst(); !eventCursor.isAfterLast(); eventCursor.moveToNext()) {
                    String eventTitle = eventCursor.getString(eventCursor.getColumnIndex("eventLocation"));
                    if (site_sign.equals(eventTitle)) {
                        int id = eventCursor.getInt(eventCursor.getColumnIndex(CalendarContract.Calendars._ID));//取得id
                        Uri deleteUri = ContentUris.withAppendedId(Uri.parse(CALENDER_EVENT_URL), id);
                        int rows = context.getContentResolver().delete(deleteUri, null, null);
                        if (rows == -1) { //事件删除失败
                            return;
                        }
                    }
                }
            }
        } finally {
            if (eventCursor != null) {
                eventCursor.close();
            }
        }
    }


    /**
     * 添加单条事件到日历
     *
     * @param context
     * @param bean
     * @param isNextDay  是否添加第二天事件
     * @param site_sign  地点事件标识，删除事件可通过找个字段统一删除
     * @param description 日历事件描述详情
     */
    public static void addCalendar(Context context, CalendarBean bean,
                                   boolean isNextDay, String site_sign,
                                   String description) {

        deleteCalendarEvent(context, site_sign);

        Calendar mCalendar = Calendar.getInstance();
        //是设置日历的时间，主要是让日历的年月日和当前同步
        mCalendar.setTimeInMillis(System.currentTimeMillis());
        // 这里时区需要设置一下，不然可能个别手机会有8个小时的时间差
        mCalendar.setTimeZone(TimeZone.getTimeZone("GMT+8"));
        //设置在几点提醒  设置的为几点
        mCalendar.set(Calendar.HOUR_OF_DAY, bean.getHour());
        //设置在几分提醒  设置的为几分
        mCalendar.set(Calendar.MINUTE, bean.getMinute());
        //下面这两个看字面意思也知道
        mCalendar.set(Calendar.SECOND, 0);
        mCalendar.set(Calendar.MILLISECOND, 0);
        /*是否直接添加第二天事件  第二天事件直接日期+1*/
        if (isNextDay) {
            mCalendar.add(Calendar.DAY_OF_MONTH, 1);
            addCalendarEvent(context, bean.getTitle(), mCalendar.getTimeInMillis(), 2, site_sign, description);
        } else {
            addCalendarEvent(context, bean.getTitle(), mCalendar.getTimeInMillis(), 3, site_sign, description);
        }
    }

    /**
     * 添加多条事件
     *
     * @param context
     * @param isNextDay   是否添加第二天事件
     * @param isNextHour  是否添加第二小时事件
     * @param site_sign   地点事件标识，删除事件可通过找个字段统一删除
     * @param description 日历事件描述详情
     */
    public static void addCalendarList(Context context, List<CalendarBean> beanList,
                                       boolean isNextDay, boolean isNextHour,
                                       String site_sign,
                                       String description) {
        deleteCalendarEvent(context, site_sign);
        for (int i = 0; i < beanList.size(); i++) {
            CalendarBean bean = beanList.get(i);
            Calendar mCalendar = Calendar.getInstance();
            //是设置日历的时间，主要是让日历的年月日和当前同步
            mCalendar.setTimeInMillis(System.currentTimeMillis());
            // 这里时区需要设置一下，不然可能个别手机会有8个小时的时间差
            mCalendar.setTimeZone(TimeZone.getTimeZone("GMT+8"));
            //设置在几点提醒  设置的为几点
            mCalendar.set(Calendar.HOUR_OF_DAY, bean.getHour());
            //设置在几分提醒  设置的为几分
            mCalendar.set(Calendar.MINUTE, bean.getMinute());
            //下面这两个看字面意思也知道
            mCalendar.set(Calendar.SECOND, 0);
            mCalendar.set(Calendar.MILLISECOND, 0);
            /*是否直接添加第二天事件  第二天事件直接日期+1*/
            if (isNextDay) {
                mCalendar.add(Calendar.DAY_OF_MONTH, 1);
                /*添加*/
                addCalendarEvent(context, bean.getTitle(), mCalendar.getTimeInMillis(), 2, site_sign, description);
            } else {
                /*要添加的日历时间*/
                long selectTime = mCalendar.getTimeInMillis();
                long systemTime;
                if (isNextHour) {
                    /*当前系统时间 + 1小时 (3600000毫秒)  这里说一下为什么要添加1小时
                     * 因为项目逻辑 需要饮水后一小时不提醒  所以添加的这个逻辑 不需要去掉即可
                     * 包括第二天添加  也是因为 饮水目标达成后 当天不提醒消息*/
                    systemTime = System.currentTimeMillis() + 3600000;
                } else {
                    systemTime = System.currentTimeMillis();
                }
                /*然后判断是否需要添加之前的*/
                if (systemTime > selectTime) {
                    mCalendar.add(Calendar.DAY_OF_MONTH, 1);
                    addCalendarEvent(context, bean.getTitle(), mCalendar.getTimeInMillis(), 2, site_sign, description);
                } else {
                    addCalendarEvent(context, bean.getTitle(), mCalendar.getTimeInMillis(), 3, site_sign, description);
                }
            }
        }
    }

}
